JavaScript 'Using' அறிக்கை மற்றும் விதிவிலக்கு கையாளுதல்: வலுவான வளங்களை சுத்தம் செய்தல்

நவீன JavaScript வளர்ச்சியில், நம்பகமான மற்றும் செயல்திறன் மிக்க பயன்பாடுகளை உருவாக்குவதற்கு சரியான வள மேலாண்மை மற்றும் பிழை கையாளுதல் ஆகியவை மிக முக்கியமானவை. using அறிக்கை நிர்ணயிக்கப்பட்ட வள அகற்றுதலுக்கான ஒரு சக்திவாய்ந்த வழிமுறையை வழங்குகிறது, பாரம்பரியமான try...catch...finally தொகுதிகளைப் பூர்த்தி செய்து, சுத்தமான, பராமரிக்கக்கூடிய குறியீட்டிற்கு வழிவகுக்கிறது. இந்த வலைப்பதிவு இடுகை using அறிக்கையின் நுணுக்கங்களைப் பற்றி ஆராயும், அதன் நன்மைகளை ஆராயும் மற்றும் அதன் பயன்பாட்டை விளக்குவதற்கு நடைமுறை எடுத்துக்காட்டுகளை வழங்கும்.

JavaScript இல் வள மேலாண்மையைப் புரிந்துகொள்வது

JavaScript, ஒரு குப்பை-சேகரிக்கப்பட்ட மொழியாக இருப்பதால், இனி அணுக முடியாத பொருள்களால் ஆக்கிரமிக்கப்பட்ட நினைவகத்தை தானாகவே மீட்டெடுக்கிறது. இருப்பினும், கோப்பு கைப்பிடிகள், பிணைய இணைப்புகள் மற்றும் தரவுத்தள இணைப்புகள் போன்ற சில வளங்கள், வளக் குறைபாடுகள் மற்றும் சாத்தியமான செயல்திறன் சிக்கல்களைத் தவிர்க்க வெளிப்படையான வெளியீட்டைப் பெறுகின்றன. இந்த வளங்களை சரியாக அகற்றத் தவறினால், நினைவக கசிவுகள், பயன்பாட்டு நிலையற்ற தன்மை மற்றும் இறுதியில், மோசமான பயனர் அனுபவம் ஏற்படலாம்.

வள மேலாண்மைக்கான பாரம்பரிய அணுகுமுறைகள் பெரும்பாலும் try...catch...finally தொகுதியைச் சார்ந்துள்ளது. இந்த அணுகுமுறை செயல்படும் அதே வேளையில், குறிப்பாக பல வளங்களைக் கையாளும் போது, அது விரிவாகவும் சிக்கலானதாகவும் மாறும். using அறிக்கை மிகவும் சுருக்கமான மற்றும் நேர்த்தியான தீர்வை வழங்குகிறது.

'Using' அறிக்கையை அறிமுகப்படுத்துதல்

ஒரு விதிவிலக்கு வீசப்பட்டதா இல்லையா என்பதைப் பொருட்படுத்தாமல், அது அறிவிக்கப்பட்ட குறியீட்டின் தொகுதி வெளியேறும் போது ஒரு வளம் தானாகவே அகற்றப்படுவதை உறுதி செய்வதன் மூலம் using அறிக்கை வள மேலாண்மையை எளிதாக்குகிறது. இது நிர்ணயிக்கப்பட்ட வள அகற்றுதலை வழங்குகிறது, அதாவது வளம் ஒரு கணிக்கக்கூடிய நேரத்தில் வெளியிடப்படும்.

using அறிக்கை Symbol.dispose அல்லது Symbol.asyncDispose முறைகளை செயல்படுத்தும் பொருள்களுடன் செயல்படுகிறது. இந்த முறைகள் வளத்தை வெளியிடுவதற்கான தர்க்கத்தை வரையறுக்கின்றன.

தொடரியல்

using அறிக்கையின் அடிப்படை தொடரியல் பின்வருமாறு:

            using (resource) {
  // Code that uses the resource
}

            

              
                Copy
              
            
          

எங்கே resource என்பது Symbol.dispose (ஒத்திசைவான அகற்றுதலுக்காக) அல்லது Symbol.asyncDispose (ஒத்திசைவற்ற அகற்றுதலுக்காக) என்பதை செயல்படுத்தும் ஒரு பொருள்.

Symbol.dispose உடன் ஒத்திசைவான வள அகற்றுதல்

ஒத்திசைவான வள அகற்றுதலுக்காக, பொருள் Symbol.dispose முறையை செயல்படுத்த வேண்டும். using தொகுதி வெளியேறும் போது இந்த முறை தானாகவே அழைக்கப்படும்.

எடுத்துக்காட்டு: தனிப்பயன் வளத்தை நிர்வகித்தல்

ஒரு கோப்பு எழுத்தாளரைப் பிரதிநிதித்துவப்படுத்தும் ஒரு எளிய எடுத்துக்காட்டை உருவாக்குவோம். இந்த வளம் இனி தேவைப்படாதபோது கோப்பை மூட Symbol.dispose முறையை செயல்படுத்தும்.

            class FileWriter {
  constructor(filePath) {
    this.filePath = filePath;
    this.fileHandle = this.openFile(filePath); // Simulate opening a file
    console.log(`File opened: ${filePath}`);
  }

  openFile(filePath) {
    // Simulate opening a file
    console.log(`Simulating file opening: ${filePath}`);
    return {}; // Return a placeholder object for the file handle
  }

  writeFile(data) {
    // Simulate writing to the file
    console.log(`Writing data to file: ${this.filePath}`);
  }

  [Symbol.dispose]() {
    // Simulate closing the file
    console.log(`Closing file: ${this.filePath}`);
    // In a real-world scenario, you would close the file handle here.
  }
}

// Using the FileWriter with the 'using' statement
using (const writer = new FileWriter('example.txt')) {
  writer.writeFile('Hello, world!');
  // The file will be automatically closed when the 'using' block exits
}

console.log('File writer has been disposed.');

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், FileWriter வகுப்பில் ஒரு Symbol.dispose முறை உள்ளது, இது கோப்பை மூடுவதை உருவகப்படுத்துகிறது. using தொகுதி வெளியேறும் போது, Symbol.dispose முறை தானாகவே அழைக்கப்படும், இது தொகுதியில் ஒரு விதிவிலக்கு ஏற்பட்டாலும் கூட கோப்பு மூடப்படுவதை உறுதி செய்கிறது.

Symbol.asyncDispose உடன் ஒத்திசைவற்ற வள அகற்றுதல்

ஒத்திசைவற்ற வள அகற்றுதலுக்காக, பொருள் Symbol.asyncDispose முறையை செயல்படுத்த வேண்டும். using தொகுதி வெளியேறும் போது இந்த முறை ஒத்திசைவற்ற முறையில் அழைக்கப்படுகிறது. நெட்வொர்க் இணைப்புகளை மூடுதல் அல்லது தரவுத்தள இணைப்புகளை வெளியிடுதல் போன்ற ஒத்திசைவற்ற துப்புரவு நடவடிக்கைகளைச் செய்யும் வளங்களுக்கு இது மிகவும் முக்கியமானது.

எடுத்துக்காட்டு: ஒத்திசைவற்ற வளத்தை நிர்வகித்தல்

தரவுத்தள இணைப்பைக் குறிக்கும் ஒரு ஒத்திசைவற்ற வளத்தின் ஒரு எடுத்துக்காட்டை உருவாக்குவோம். இந்த வளம் இணைப்பை ஒத்திசைவற்ற முறையில் மூட Symbol.asyncDispose முறையை செயல்படுத்தும்.

            class DatabaseConnection {
  constructor(connectionString) {
    this.connectionString = connectionString;
    this.connection = this.connect(connectionString); // Simulate connecting to the database
    console.log(`Database connection established: ${connectionString}`);
  }

  async connect(connectionString) {
    // Simulate connecting to the database asynchronously
    console.log(`Simulating asynchronous database connection: ${connectionString}`);
    return {}; // Return a placeholder object for the database connection
  }

  async query(sql) {
    // Simulate executing a query asynchronously
    console.log(`Executing query: ${sql}`);
    return []; // Return a placeholder result
  }

  async [Symbol.asyncDispose]() {
    // Simulate closing the database connection asynchronously
    console.log(`Closing database connection: ${this.connectionString}`);
    // In a real-world scenario, you would close the database connection here asynchronously.
    await new Promise(resolve => setTimeout(resolve, 500)); // Simulate asynchronous operation
    console.log(`Database connection closed: ${this.connectionString}`);
  }
}

// Using the DatabaseConnection with the 'using' statement
async function main() {
  await using (const connection = new DatabaseConnection('mongodb://localhost:27017')) {
    await connection.query('SELECT * FROM users');
    // The database connection will be automatically closed asynchronously when the 'using' block exits
  }

  console.log('Database connection has been disposed.');
}

main();

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், DatabaseConnection வகுப்பில் ஒரு Symbol.asyncDispose முறை உள்ளது, இது தரவுத்தள இணைப்பை ஒத்திசைவற்ற முறையில் மூடுவதை உருவகப்படுத்துகிறது. ஒத்திசைவற்ற அகற்றும் செயல்பாடு நிறைவடையும் வரை நிரல் தொடர்வதை உறுதிசெய்ய using அறிக்கை await முக்கிய வார்த்தையுடன் பயன்படுத்தப்படுகிறது. இது வள கசிவுகளைத் தடுப்பதற்கும், தரவுத்தள இணைப்பு சரியாக மூடப்படுவதை உறுதி செய்வதற்கும் முக்கியமானது.

'Using' அறிக்கையைப் பயன்படுத்துவதன் நன்மைகள்

• நிர்ணயிக்கப்பட்ட வள அகற்றுதல்: இனி தேவைப்படாதபோது வளங்கள் வெளியிடப்படுவதை உறுதிசெய்கிறது, இது வள கசிவுகளைத் தடுக்கிறது.
• குறியீட்டை எளிதாக்கியது: பாரம்பரிய try...catch...finally தொகுதிகளைக் காட்டிலும் வள மேலாண்மைக்குத் தேவையான கொதிகலன் குறியீட்டைக் குறைக்கிறது.
• படிக்கக்கூடிய தன்மையை மேம்படுத்தியது: வள பயன்பாட்டின் எல்லையைத் தெளிவாகக் குறிப்பதன் மூலம் குறியீட்டைப் படிக்க எளிதாக்குகிறது மற்றும் புரிந்துகொள்ள எளிதாக்குகிறது.
• விதிவிலக்கு பாதுகாப்பு: using தொகுதியில் விதிவிலக்குகள் ஏற்பட்டாலும் வளங்கள் வெளியிடப்படுவதை உறுதி செய்கிறது.
• ஒத்திசைவற்ற ஆதரவு: Symbol.asyncDispose மூலம் ஒத்திசைவற்ற வள அகற்றுதலை வழங்குகிறது, நவீன JavaScript பயன்பாடுகளுக்கு அவசியம்.

'Using' ஐ 'Try...Catch' உடன் இணைத்தல்

உள்ளடக்கத்தைப் பயன்படுத்தும் போது ஏற்படக்கூடிய விதிவிலக்குகளைக் கையாள using அறிக்கையை try...catch தொகுதிகளுடன் திறம்பட இணைக்க முடியும். ஒரு விதிவிலக்கு வீசப்பட்டதா இல்லையா என்பதைப் பொருட்படுத்தாமல் வளம் அகற்றப்படும் என்பதை using அறிக்கை உறுதிப்படுத்துகிறது.

எடுத்துக்காட்டு: 'Using' உடன் விதிவிலக்குகளைக் கையாளுதல்

            class Resource {
  constructor() {
    console.log('Resource acquired.');
  }

  use() {
    // Simulate a potential error
    const random = Math.random();
    if (random < 0.5) {
      throw new Error('Simulated error while using the resource.');
    }
    console.log('Resource used successfully.');
  }

  [Symbol.dispose]() {
    console.log('Resource disposed.');
  }
}

function processResource() {
  try {
    using (const resource = new Resource()) {
      resource.use();
    }
  } catch (error) {
    console.error(`An error occurred: ${error.message}`);
  }
  console.log('Resource processing complete.');
}

processResource();

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், try...catch தொகுதி resource.use() முறையால் வீசப்படக்கூடிய எந்த விதிவிலக்குகளையும் பிடிக்கிறது. ஒரு விதிவிலக்கு பிடிக்கப்பட்டாலும் இல்லாவிட்டாலும் வளம் அகற்றப்படுவதை using அறிக்கை உறுதி செய்கிறது.

பல வளங்களுடன் 'Using'

using அறிக்கையை ஒரே நேரத்தில் பல வளங்களை நிர்வகிக்க பயன்படுத்தலாம். இந்த அறிவிப்பைச் செய்ய, using தொகுதியின் உள்ளே பல வளங்களை அறிவிக்கலாம், ஒவ்வொன்றும் அரைப்புள்ளியால் பிரிக்கப்படுகின்றன.

எடுத்துக்காட்டு: பல வளங்களை நிர்வகித்தல்

            class Resource1 {
  constructor(name) {
    this.name = name;
    console.log(`${name}: Resource acquired.`);
  }

  [Symbol.dispose]() {
    console.log(`${this.name}: Resource disposed.`);
  }
}

class Resource2 {
  constructor(name) {
    this.name = name;
    console.log(`${name}: Resource acquired.`);
  }

  [Symbol.dispose]() {
    console.log(`${this.name}: Resource disposed.`);
  }
}

using (const resource1 = new Resource1('Resource 1'); const resource2 = new Resource2('Resource 2')) {
  console.log('Using both resources.');
}

console.log('Resource processing complete.');

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், resource1 மற்றும் resource2 ஆகிய இரண்டு வளங்கள் ஒரே using தொகுதியில் நிர்வகிக்கப்படுகின்றன. தொகுதி வெளியேறியதும், இரண்டு வளங்களும் அகற்றப்படும்.

'Using' அறிக்கையைப் பயன்படுத்துவதற்கான சிறந்த நடைமுறைகள்

• 'Symbol.dispose' அல்லது 'Symbol.asyncDispose' ஐ செயல்படுத்துங்கள்: உங்கள் வள பொருள்கள் பொருத்தமான அகற்றும் முறையை செயல்படுத்துவதை உறுதிப்படுத்தவும்.
• விதிவிலக்குகளைக் கையாளுங்கள்: வளத்தைப் பயன்படுத்தும் போது ஏற்படக்கூடிய விதிவிலக்குகளைக் கையாள try...catch தொகுதிகளைப் பயன்படுத்தவும்.
• சரியான வரிசையில் வளங்களை அகற்றுங்கள்: வளங்களுக்கு சார்புகள் இருந்தால், அவற்றை வாங்கியதன் தலைகீழ் வரிசையில் அகற்றவும்.
• நீண்ட கால வளங்களைத் தவிர்க்கவும்: வள கசிவுகளின் அபாயத்தைக் குறைக்க, வளங்களை மிகச் சிறிய அளவில் வைத்துக் கொள்ளுங்கள்.
• ஒத்திசைவற்ற செயல்பாடுகளுக்கு ஒத்திசைவற்ற அகற்றுதலைப் பயன்படுத்தவும்: ஒத்திசைவற்ற துப்புரவு நடவடிக்கைகளை தேவைப்படும் வளங்களுக்கு Symbol.asyncDispose ஐப் பயன்படுத்தவும்.

உலாவி மற்றும் JavaScript எஞ்சின் ஆதரவு

using அறிக்கை JavaScript இல் ஒப்பீட்டளவில் ஒரு புதிய அம்சம் மற்றும் ECMAScript 2024 அல்லது அதற்குப் பிந்தையதை ஆதரிக்கும் ஒரு நவீன JavaScript எஞ்சின் தேவை. பெரும்பாலான நவீன உலாவிகள் மற்றும் Node.js பதிப்புகள் இந்த அம்சத்தை ஆதரிக்கின்றன, ஆனால் உங்கள் இலக்கு சூழலுக்கான இணக்கத்தன்மையை சரிபார்ப்பது அவசியம். பழைய சூழல்களை நீங்கள் ஆதரிக்க வேண்டியிருந்தால், குறியீட்டை பழைய JavaScript பதிப்பிற்கு மாற்ற அல்லது try...finally போன்ற மாற்று வள மேலாண்மை நுட்பங்களைப் பயன்படுத்துவதற்கு பேபெல் போன்ற டிரான்ஸ்பைலரைப் பயன்படுத்தவும்.

பயன்பாட்டு நிகழ்வுகள் மற்றும் நிஜ-உலக பயன்பாடுகள்

நிர்ணயிக்கப்பட்ட வள மேலாண்மை முக்கியமான பல சூழ்நிலைகளில் using அறிக்கை பொருந்தும்.

• கோப்பு கையாளுதல்: தரவு சிதைவு மற்றும் வளக் குறைபாட்டைத் தடுக்கும் வகையில், பயன்பாட்டிற்குப் பிறகு கோப்புகள் சரியாக மூடப்படுவதை உறுதி செய்தல்.
• தரவுத்தள இணைப்புகள்: இணைப்பு பூல் குறைதல் மற்றும் செயல்திறன் சிக்கல்களைத் தவிர்ப்பதற்காக தரவுத்தள இணைப்புகளை உடனடியாக வெளியிடுதல்.
• பிணைய இணைப்புகள்: வள கசிவுகளைத் தடுக்கவும், பிணைய செயல்திறனை மேம்படுத்தவும் நெட்வொர்க் சாக்கெட்டுகளையும் ஸ்ட்ரீம்களையும் மூடுதல்.
• WebSockets: நம்பகமான தொடர்பு மற்றும் வளக் குறைபாட்டைத் தடுக்க WebSocket இணைப்புகளை முறையாக மூடுதல்.
• கிராபிக்ஸ் வளங்கள்: கிராபிக்ஸ்-தீவிர பயன்பாடுகளில் நினைவக கசிவுகளைத் தடுக்க டெக்ஸ்சர்கள் மற்றும் இடையகங்கள் போன்ற கிராபிக்ஸ் வளங்களை வெளியிடுதல்.
• வன்பொருள் வளங்கள்: மோதல்களைத் தடுக்கவும், சரியான செயல்பாட்டை உறுதிப்படுத்தவும் சென்சார்கள் மற்றும் ஆக்சுவேட்டர்கள் போன்ற வன்பொருள் வளங்களுக்கான அணுகலை நிர்வகித்தல்.

'Using' அறிக்கைக்கு மாற்றுகள்

using அறிக்கை வளங்களை நிர்வகிப்பதற்கான ஒரு வசதியான மற்றும் திறமையான வழியை வழங்கினாலும், using அறிக்கை கிடைக்காத அல்லது பொருத்தமற்ற சூழ்நிலைகளில் பயன்படுத்தக்கூடிய மாற்று அணுகுமுறைகள் உள்ளன.

• Try...Finally: வளங்கள் வெளியிடப்படுவதை உறுதிப்படுத்த பாரம்பரியமான try...finally தொகுதியைப் பயன்படுத்தலாம், ஆனால் இதற்கு அதிக கொதிகலன் குறியீடு தேவைப்படுகிறது.
• வள ரேப்பர்கள்: வள கையகப்படுத்தல் மற்றும் அகற்றுதலை அவற்றின் கன்ஸ்ட்ரக்டர் மற்றும் டிஸ்ட்ரக்டரில் கையாளும் தனிப்பயன் வள ரேப்பர் பொருள்களை உருவாக்குதல்.
• கையேடு வள மேலாண்மை: குறியீட்டுத் தொகுதியின் முடிவில் வளங்களை கைமுறையாக வெளியிடுதல், ஆனால் இந்த அணுகுமுறை பிழைக்கு ஆளாகும் மற்றும் கவனமாகச் செய்யாவிட்டால் வள கசிவுகளுக்கு வழிவகுக்கும்.

முடிவுரை

JavaScript using அறிக்கை நிர்ணயிக்கப்பட்ட வள மேலாண்மை மற்றும் விதிவிலக்கு கையாளுதலை உறுதி செய்வதற்கான ஒரு சக்திவாய்ந்த கருவியாகும். வளங்களை வெளியிடுவதற்கான சுருக்கமான மற்றும் நேர்த்தியான வழியை வழங்குவதன் மூலம், இது நினைவக கசிவுகளைத் தடுக்க உதவுகிறது, பயன்பாட்டு ஸ்திரத்தன்மையை மேம்படுத்துகிறது, மேலும் சுத்தமான, பராமரிக்கக்கூடிய குறியீட்டிற்கு வழிவகுக்கிறது. using அறிக்கை, அதன் ஒத்திசைவான (Symbol.dispose) மற்றும் ஒத்திசைவற்ற (Symbol.asyncDispose) வகைகளுடன், வலுவான மற்றும் செயல்திறன் மிக்க JavaScript பயன்பாடுகளை உருவாக்குவதற்கு அவசியம். JavaScript தொடர்ந்து உருவாகி வருவதால், இந்த வள மேலாண்மை நுட்பங்களில் தேர்ச்சி பெறுவது உலகெங்கிலும் உள்ள டெவலப்பர்களுக்கு பெருகிய முறையில் முக்கியத்துவம் பெறும்.

உங்கள் JavaScript வளர்ச்சி நடைமுறைகளை மேம்படுத்தவும், உலகளாவிய பார்வையாளர்களுக்காக மிகவும் நம்பகமான மற்றும் திறமையான பயன்பாடுகளை உருவாக்கவும் using அறிக்கையை ஏற்றுக்கொள்ளுங்கள்.